Skip to content

Method: ClassClassFileWriter(String, boolean)

1: package de.fhdw.wtf.generator.writer.writer;
2:
3: import java.util.Collection;
4: import java.util.HashMap;
5: import java.util.Vector;
6:
7: import org.apache.velocity.context.Context;
8:
9: import de.fhdw.wtf.generator.java.generatorModel.GenAspectAttribute;
10: import de.fhdw.wtf.generator.java.generatorModel.GenAttribute;
11: import de.fhdw.wtf.generator.java.generatorModel.GenAttributeModifier;
12: import de.fhdw.wtf.generator.java.generatorModel.GenClass;
13: import de.fhdw.wtf.generator.java.generatorModel.GenClassClass;
14: import de.fhdw.wtf.generator.java.generatorModel.GenClassModifier;
15: import de.fhdw.wtf.generator.java.generatorModel.GenFullParsedOperationState;
16: import de.fhdw.wtf.generator.java.generatorModel.GenInterfaceClass;
17: import de.fhdw.wtf.generator.java.generatorModel.GenJavaAttribute;
18: import de.fhdw.wtf.generator.java.generatorModel.GenOperation;
19: import de.fhdw.wtf.generator.java.generatorModel.GenPrimitiveClass;
20: import de.fhdw.wtf.generator.java.generatorModel.GenSimpleOperationState;
21: import de.fhdw.wtf.generator.java.visitor.GenAttributeVisitorReturn;
22: import de.fhdw.wtf.generator.java.visitor.GenClassVisitor;
23: import de.fhdw.wtf.generator.java.visitor.GenOperationStateVisitor;
24:
25: /**
26: * Writes Java files from the JavaGenerationModel type {@link GenClass}.
27: */
28: public abstract class ClassClassFileWriter extends ClassFileWriter {
29:         
30:         private static final String CONSTRUCTOR_KEY = "constructors";
31:         private static final String CONSTRUCTOR_COMMENT_KEY = "constructorComment";
32:         static final String ATTRIBUTES_KEY = "attributes";
33:         
34:         public ClassClassFileWriter(final String template, final boolean fullyQualified) {
35:                 super(template, fullyQualified);
36:         }
37:         
38:         /**
39:          * Writes the file for the given {@link GenClass} c.
40:          *
41:          * @param c
42:          */
43:         void writeClassClass(final GenClassClass c) {
44:                 this.writeClass(c);
45:                 this.setUpContext(c, this.getCurrentContext());
46:         }
47:         
48:         /**
49:          * Sets up the {@link org.apache.velocity.VelocityContext} with all necessary values for classes.
50:          *
51:          * @param c
52:          * {@link GenClassClass} class to write
53:          * @param currentContext
54:          * the {@link org.apache.velocity.VelocityContext} for the class
55:          */
56:         private void setUpContext(final GenClassClass c, final Context currentContext) {
57:                 this.setClassModifier(c, currentContext);
58:                 this.setConstructors(c, currentContext);
59:                 this.setExtends(c, currentContext);
60:         }
61:         
62:         /**
63:          * Sets all values for the {@link Classmodifier} of {@link GenClass} {@code c} to the {@link Context}.
64:          *
65:          * @param c
66:          * @param currentContext
67:          */
68:         private void setClassModifier(final GenClassClass c, final Context currentContext) {
69:                 final Vector<String> modifiers = new Vector<>();
70:                 for (final GenClassModifier modifier : c.getModifieres()) {
71:                         modifiers.add(modifier.toString());
72:                 }
73:                 currentContext.put(CLASS_MODIFIERS_KEY, modifiers);
74:         }
75:         
76:         Vector<HashMap<String, Object>> getAttributes(final Collection<? extends GenAttribute> attributes) {
77:                 final Vector<HashMap<String, Object>> result = new Vector<>();
78:                 for (final GenAttribute attribute : attributes) {
79:                         final HashMap<String, Object> current = new HashMap<>();
80:                         current.put(VISIBILITY_KEY, attribute.getVisibility().toString());
81:                         current.put(NAME_KEY, attribute.getName());
82:                         current.put(TYP_KEY, this.typeToString(attribute.getTyp()));
83:                         final Vector<String> modifiers = new Vector<>();
84:                         for (final GenAttributeModifier modifier : attribute.getModifiers()) {
85:                                 modifiers.add(modifier.toString());
86:                         }
87:                         current.put(MODIFIERS_KEY, modifiers);
88:                         attribute.accept(new GenAttributeVisitorReturn<GenAttribute>() {
89:                                 @Override
90:                                 public GenAttribute handleJavaAttribute(final GenJavaAttribute attribute) {
91:                                         return attribute;
92:                                 }
93:                                 
94:                                 @Override
95:                                 public GenAttribute handleAspectAttribute(final GenAspectAttribute attribute) {
96:                                         current.put(TARGED_CLASS_KEY, ClassClassFileWriter.this.typeToString(attribute.getOwner()) + ".");
97:                                         return attribute;
98:                                 }
99:                         });
100:                         result.add(current);
101:                 }
102:                 return result;
103:         }
104:         
105:         /**
106:          * Sets all values for the constructor declaration of {@link GenClass} c to the {@link Context}.
107:          *
108:          * @param c
109:          * @param currentContext
110:          */
111:         private void setConstructors(final GenClass c, final Context currentContext) {
112:                 c.accept(new GenClassVisitor() {
113:                         @Override
114:                         public void handle(final GenInterfaceClass interfaceClass) {
115:                                 // nothing to do
116:                         }
117:                         
118:                         @Override
119:                         public void handle(final GenClassClass classClass) {
120:                                 final Vector<HashMap<String, Object>> constructors = new Vector<>();
121:                                 for (final GenOperation constructor : classClass.getConstructors()) {
122:                                         constructor.getState().accept(new GenOperationStateVisitor() {
123:                                                 @Override
124:                                                 public void handle(final GenFullParsedOperationState s) {
125:                                                         final HashMap<String, Object> current = new HashMap<>();
126:                                                         current.put(VISIBILITY_KEY, s.getVisibility().toString());
127:                                                         current.put(
128:                                                                         PARAMETER_KEY,
129:                                                                         ClassClassFileWriter.this.getParamString(constructor.getParameters()));
130:                                                         current.put(METHOD_KEY, s.getMethodBody());
131:                                                         current.put(CONSTRUCTOR_COMMENT_KEY, s.getComment().getText());
132:                                                         current.put(EXCEPTIONS_KEY, ClassClassFileWriter.this.getExceptionString(s.getExceptions()));
133:                                                         constructors.add(current);
134:                                                 }
135:                                                 
136:                                                 @Override
137:                                                 public void handle(final GenSimpleOperationState s) {
138:                                                         // nothing to do
139:                                                 }
140:                                         });
141:                                         
142:                                 }
143:                                 currentContext.put(CONSTRUCTOR_KEY, constructors);
144:                         }
145:                         
146:                         @Override
147:                         public void handle(final GenPrimitiveClass primitiveClass) {
148:                                 // nothing to do
149:                         }
150:                 });
151:         }
152:         
153:         private void setExtends(final GenClassClass c, final Context currentContext) {
154:                 if (c.getExtend() != null) {
155:                         currentContext.put(EXTENDS_KEY, EXTENDS + this.typeToString(c.getExtend()));
156:                 } else {
157:                         currentContext.put(EXTENDS_KEY, "");
158:                 }
159:         }
160:         
161: }